﻿//
//
//using System;
//using System.Globalization;

//namespace Fozzy.Gedcom
//{
//    public class Lines                          : Fozzy.Xml.Lines
//    {
//        #region States
//            const char                          Char_n      = '\n'                                                                  ;
//            static string                       n           = Char_n.ToString()                                                     ;
//            const string                        r           = "\r"                                                                  ;
//            const string                        rn          = "\r\n"                                                                ;
//        #endregion

//            //    if (value.Length < ValueLimit && !value.Contains("\r") && !value.Contains("\n"))

//        #region States
//            public bool                        Be_Clean     { get { return Be_Short && Be_Without_N  && Be_Without_R                ; } }
//            private bool                       Be_Short     { get { return ToString().Length < Limit                                 ; } }
//            private bool                       Be_Without_N { get { return !ToString().Contains(n)                                   ; } }
//            private bool                       Be_Without_R { get { return !ToString().Contains(r)                                   ; } }
//        #endregion

//        #region Properties
//            protected override Name       Cleaner     { get { return ToString().Replace(rn, n).Replace(r, n)                   ; } }
//            protected override Name       Splitter    { get { return new Name(ToString().Split(Char_n))                  ; } }
//        #endregion

//        #region Constructeur
//            public Lines(Name source)                  : this(source.ToString())
//            {}
//            public Lines(string source)                      : base(_Element)
//            {}
//            public Lines(Match match)                        : base(match.Groups("data"))
//            {}
//        #endregion

//            protected override void Line()
//            {
//                for (int index = 0; index < Name.Count; index++)
//                {
//                    // Write each line but don't exceed the line limit, loop here and write each chunk out at a time.
//                    int chunkCount = (Length + Limit - 1) / Limit;
//                    for (int chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++)
//                    {
//                        // Current position in the value.
//                        int pos = chunkIndex * Limit;
//                        // Current value chunk to write.
//                        string chunk = Name.ToString().Substring(pos, Math.Min(Length - pos, Limit));
//                        // Always use the original level and tag for the first line, but use the concatenation tag (CONT) for all other lines.
//                        if (lineIndex == 0 && chunkIndex == 0)
//                        {
//                            //                writer.WriteLine(string.Format(CultureInfo.InvariantCulture,  "{0} {1} {2}", level, tag, chunk));
//                            //            }
//                            //            else
//                            //            {
//                            //                writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} {1} {2}", level + 1, "CONC", chunk));
//                            //            }
//                            //        }

//                        }
//                    }
//                }

//                //for (int lineIndex = 0; lineIndex < Name.Count; lineIndex++)
//                //{
//                //    string line = Name.Instance(lineIndex)                                      ;
//                //    // Write each line but don't exceed the line limit, loop here and write each chunk out at a time.
//                //    int chunkCount = (line.Length + Limit - 1) / Limit                          ;
//                //    for (int chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++)
//                //    {
//                //        // Current position in the value.
//                //        int pos = chunkIndex * Limit                                            ;
//                //        // Current value chunk to write.
//                //        string chunk = line.Substring(pos, Math.Min(line.Length - pos, Limit))  ;
//                //        // Always use the original level and tag for the first line, but use the concatenation tag (CONT) for all other lines.
//                //        if (lineIndex == 0 && chunkIndex == 0)
//                //        {
//                //    //                writer.WriteLine(string.Format(CultureInfo.InvariantCulture,  "{0} {1} {2}", level, tag, chunk));
//                //    //            }
//                //    //            else
//                //    //            {
//                //    //                writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} {1} {2}", level + 1, "CONC", chunk));
//                //    //            }
//                //    //        }

//                //}
//            }

            

//        //    // Process each line.
//        //    for (int lineIndex = 0; lineIndex < lines.Length; lineIndex++)
//        //    {
//        //        // The current line processing.
//        //        string line = lines[lineIndex];

//        //        // Write each line but don't exceed the line limit, loop here
//        //        // and write each chunk out at a time.
//        //        int chunkCount = (line.Length + ValueLimit - 1) / ValueLimit;

//        //        for (int chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++)
//        //        {
//        //            // Current position in the value.
//        //            int pos = chunkIndex * ValueLimit;

//        //            // Current value chunk to write.
//        //            string chunk = line.Substring(pos, Math.Min(line.Length - pos, ValueLimit));

//        //            // Always use the original level and tag for the first line, but use
//        //            // the concatenation tag (CONT) for all other lines.
//        //            if (lineIndex == 0 && chunkIndex == 0)
//        //            {
//        //                writer.WriteLine(string.Format(CultureInfo.InvariantCulture,  "{0} {1} {2}", level, tag, chunk));
//        //            }
//        //            else
//        //            {
//        //                writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} {1} {2}", level + 1, "CONC", chunk));
//        //            }
//        //        }

//        //        // All lines except the last line have the continue (CONT) tag.
//        //        if (lineIndex < lines.Length - 1) writer.WriteLine(string.Format(CultureInfo.InvariantCulture,  "{0} {1}", level + 1, "CONT"));
//        //    }


//    }
//}
    
